namespace nwWCF
{
	using System.Collections.Generic;

    /// <summary>
    /// SampleServiceName Service Class Handler
    /// </summary>
    public partial class SampleServiceName : ISampleServiceName
    {
        #region Private Members

        /// <summary>
        /// DataManager private instance for CRUD operations
        /// </summary>
        private DataManager dataManager = new DataManager();

        #endregion

        #region ISampleServiceName Member		
		
        #region Category CRUD Operations

        /// <summary>
        /// Create Category. 
        /// </summary>
        /// <param name="category">Target Category.</param>
        /// <returns>return Category Id </returns>
        public string CreateCategory(nwDAL.Category category)
        {
            return dataManager.CreateEntity(category);
        }

		/// <summary>
        /// Get Categories ID.
        /// </summary>
        /// <returns>Categories ID</returns>
		public string GetCategoryObjectId(nwDAL.Category category)
        {
			return dataManager.GetEntityId<nwDAL.Category>(category);
		}
		
        /// <summary>
        /// Read Categories .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Categories.</returns>
        public List<nwDAL.Category> ReadCategories(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Category>(startIndex, count);
        }
		
		/// <summary>
        /// Read Categories .
        /// </summary>
        /// <returns>List of Categories.</returns>
        public List<nwDAL.Category> ReadAllCategories()
        {
            return dataManager.ReadEntities<nwDAL.Category>();
        }

        /// <summary>
        /// Read Category.
        /// </summary>
        /// <param name="entityId">Category Id that will be read.</param>
        /// <returns>Target Category.</returns>
        public nwDAL.Category ReadCategory(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Category>(entityId);
        }

        /// <summary>
        /// Update Category.
        /// </summary>
        /// <param name="category">updated Category .</param>
        /// <returns>Updated Category Id .</returns>
        public string UpdateCategory(nwDAL.Category category)
        {
            return dataManager.UpdateEntity(category);
        }

        /// <summary>
        /// Delete Category.
        /// </summary>
        /// <param name="entityId">Target Category Id.</param>
        /// <returns>Deleted Category Id.</returns>
        public string DeleteCategoryById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Category>(entityId);
        }
		
		/// <summary>
        /// Delete Category.
        /// </summary>
        /// <param name="entityId">Target Category.</param>
        /// <returns>Deleted Category.</returns>
        public string DeleteCategory(nwDAL.Category category)
        {
			string entityId = this.GetCategoryObjectId(category);
			return this.DeleteCategoryById(entityId);
		}
		
		/// <summary>
        /// Searches the Category.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Category> SearchCategory(nwDAL.Category searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Category>(searchParameters);
        }
		
        #endregion
		
        #region Customer CRUD Operations

        /// <summary>
        /// Create Customer. 
        /// </summary>
        /// <param name="customer">Target Customer.</param>
        /// <returns>return Customer Id </returns>
        public string CreateCustomer(nwDAL.Customer customer)
        {
            return dataManager.CreateEntity(customer);
        }

		/// <summary>
        /// Get Customers ID.
        /// </summary>
        /// <returns>Customers ID</returns>
		public string GetCustomerObjectId(nwDAL.Customer customer)
        {
			return dataManager.GetEntityId<nwDAL.Customer>(customer);
		}
		
        /// <summary>
        /// Read Customers .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Customers.</returns>
        public List<nwDAL.Customer> ReadCustomers(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Customer>(startIndex, count);
        }
		
		/// <summary>
        /// Read Customers .
        /// </summary>
        /// <returns>List of Customers.</returns>
        public List<nwDAL.Customer> ReadAllCustomers()
        {
            return dataManager.ReadEntities<nwDAL.Customer>();
        }

        /// <summary>
        /// Read Customer.
        /// </summary>
        /// <param name="entityId">Customer Id that will be read.</param>
        /// <returns>Target Customer.</returns>
        public nwDAL.Customer ReadCustomer(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Customer>(entityId);
        }

        /// <summary>
        /// Update Customer.
        /// </summary>
        /// <param name="customer">updated Customer .</param>
        /// <returns>Updated Customer Id .</returns>
        public string UpdateCustomer(nwDAL.Customer customer)
        {
            return dataManager.UpdateEntity(customer);
        }

        /// <summary>
        /// Delete Customer.
        /// </summary>
        /// <param name="entityId">Target Customer Id.</param>
        /// <returns>Deleted Customer Id.</returns>
        public string DeleteCustomerById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Customer>(entityId);
        }
		
		/// <summary>
        /// Delete Customer.
        /// </summary>
        /// <param name="entityId">Target Customer.</param>
        /// <returns>Deleted Customer.</returns>
        public string DeleteCustomer(nwDAL.Customer customer)
        {
			string entityId = this.GetCustomerObjectId(customer);
			return this.DeleteCustomerById(entityId);
		}
		
		/// <summary>
        /// Searches the Customer.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Customer> SearchCustomer(nwDAL.Customer searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Customer>(searchParameters);
        }
		
        #endregion
		
        #region CustomerCustomerDemo CRUD Operations

        /// <summary>
        /// Create CustomerCustomerDemo. 
        /// </summary>
        /// <param name="customercustomerdemo">Target CustomerCustomerDemo.</param>
        /// <returns>return CustomerCustomerDemo Id </returns>
        public string CreateCustomerCustomerDemo(nwDAL.CustomerCustomerDemo customercustomerdemo)
        {
            return dataManager.CreateEntity(customercustomerdemo);
        }

		/// <summary>
        /// Get CustomerCustomerDemos ID.
        /// </summary>
        /// <returns>CustomerCustomerDemos ID</returns>
		public string GetCustomerCustomerDemoObjectId(nwDAL.CustomerCustomerDemo customercustomerdemo)
        {
			return dataManager.GetEntityId<nwDAL.CustomerCustomerDemo>(customercustomerdemo);
		}
		
        /// <summary>
        /// Read CustomerCustomerDemos .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of CustomerCustomerDemos.</returns>
        public List<nwDAL.CustomerCustomerDemo> ReadCustomerCustomerDemos(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.CustomerCustomerDemo>(startIndex, count);
        }
		
		/// <summary>
        /// Read CustomerCustomerDemos .
        /// </summary>
        /// <returns>List of CustomerCustomerDemos.</returns>
        public List<nwDAL.CustomerCustomerDemo> ReadAllCustomerCustomerDemos()
        {
            return dataManager.ReadEntities<nwDAL.CustomerCustomerDemo>();
        }

        /// <summary>
        /// Read CustomerCustomerDemo.
        /// </summary>
        /// <param name="entityId">CustomerCustomerDemo Id that will be read.</param>
        /// <returns>Target CustomerCustomerDemo.</returns>
        public nwDAL.CustomerCustomerDemo ReadCustomerCustomerDemo(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.CustomerCustomerDemo>(entityId);
        }

        /// <summary>
        /// Update CustomerCustomerDemo.
        /// </summary>
        /// <param name="customercustomerdemo">updated CustomerCustomerDemo .</param>
        /// <returns>Updated CustomerCustomerDemo Id .</returns>
        public string UpdateCustomerCustomerDemo(nwDAL.CustomerCustomerDemo customercustomerdemo)
        {
            return dataManager.UpdateEntity(customercustomerdemo);
        }

        /// <summary>
        /// Delete CustomerCustomerDemo.
        /// </summary>
        /// <param name="entityId">Target CustomerCustomerDemo Id.</param>
        /// <returns>Deleted CustomerCustomerDemo Id.</returns>
        public string DeleteCustomerCustomerDemoById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.CustomerCustomerDemo>(entityId);
        }
		
		/// <summary>
        /// Delete CustomerCustomerDemo.
        /// </summary>
        /// <param name="entityId">Target CustomerCustomerDemo.</param>
        /// <returns>Deleted CustomerCustomerDemo.</returns>
        public string DeleteCustomerCustomerDemo(nwDAL.CustomerCustomerDemo customercustomerdemo)
        {
			string entityId = this.GetCustomerCustomerDemoObjectId(customercustomerdemo);
			return this.DeleteCustomerCustomerDemoById(entityId);
		}
		
		/// <summary>
        /// Searches the CustomerCustomerDemo.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.CustomerCustomerDemo> SearchCustomerCustomerDemo(nwDAL.CustomerCustomerDemo searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.CustomerCustomerDemo>(searchParameters);
        }
		
        #endregion
		
        #region CustomerDemographic CRUD Operations

        /// <summary>
        /// Create CustomerDemographic. 
        /// </summary>
        /// <param name="customerdemographic">Target CustomerDemographic.</param>
        /// <returns>return CustomerDemographic Id </returns>
        public string CreateCustomerDemographic(nwDAL.CustomerDemographic customerdemographic)
        {
            return dataManager.CreateEntity(customerdemographic);
        }

		/// <summary>
        /// Get CustomerDemographics ID.
        /// </summary>
        /// <returns>CustomerDemographics ID</returns>
		public string GetCustomerDemographicObjectId(nwDAL.CustomerDemographic customerdemographic)
        {
			return dataManager.GetEntityId<nwDAL.CustomerDemographic>(customerdemographic);
		}
		
        /// <summary>
        /// Read CustomerDemographics .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of CustomerDemographics.</returns>
        public List<nwDAL.CustomerDemographic> ReadCustomerDemographics(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.CustomerDemographic>(startIndex, count);
        }
		
		/// <summary>
        /// Read CustomerDemographics .
        /// </summary>
        /// <returns>List of CustomerDemographics.</returns>
        public List<nwDAL.CustomerDemographic> ReadAllCustomerDemographics()
        {
            return dataManager.ReadEntities<nwDAL.CustomerDemographic>();
        }

        /// <summary>
        /// Read CustomerDemographic.
        /// </summary>
        /// <param name="entityId">CustomerDemographic Id that will be read.</param>
        /// <returns>Target CustomerDemographic.</returns>
        public nwDAL.CustomerDemographic ReadCustomerDemographic(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.CustomerDemographic>(entityId);
        }

        /// <summary>
        /// Update CustomerDemographic.
        /// </summary>
        /// <param name="customerdemographic">updated CustomerDemographic .</param>
        /// <returns>Updated CustomerDemographic Id .</returns>
        public string UpdateCustomerDemographic(nwDAL.CustomerDemographic customerdemographic)
        {
            return dataManager.UpdateEntity(customerdemographic);
        }

        /// <summary>
        /// Delete CustomerDemographic.
        /// </summary>
        /// <param name="entityId">Target CustomerDemographic Id.</param>
        /// <returns>Deleted CustomerDemographic Id.</returns>
        public string DeleteCustomerDemographicById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.CustomerDemographic>(entityId);
        }
		
		/// <summary>
        /// Delete CustomerDemographic.
        /// </summary>
        /// <param name="entityId">Target CustomerDemographic.</param>
        /// <returns>Deleted CustomerDemographic.</returns>
        public string DeleteCustomerDemographic(nwDAL.CustomerDemographic customerdemographic)
        {
			string entityId = this.GetCustomerDemographicObjectId(customerdemographic);
			return this.DeleteCustomerDemographicById(entityId);
		}
		
		/// <summary>
        /// Searches the CustomerDemographic.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.CustomerDemographic> SearchCustomerDemographic(nwDAL.CustomerDemographic searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.CustomerDemographic>(searchParameters);
        }
		
        #endregion
		
        #region Employee CRUD Operations

        /// <summary>
        /// Create Employee. 
        /// </summary>
        /// <param name="employee">Target Employee.</param>
        /// <returns>return Employee Id </returns>
        public string CreateEmployee(nwDAL.Employee employee)
        {
            return dataManager.CreateEntity(employee);
        }

		/// <summary>
        /// Get Employees ID.
        /// </summary>
        /// <returns>Employees ID</returns>
		public string GetEmployeeObjectId(nwDAL.Employee employee)
        {
			return dataManager.GetEntityId<nwDAL.Employee>(employee);
		}
		
        /// <summary>
        /// Read Employees .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Employees.</returns>
        public List<nwDAL.Employee> ReadEmployees(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Employee>(startIndex, count);
        }
		
		/// <summary>
        /// Read Employees .
        /// </summary>
        /// <returns>List of Employees.</returns>
        public List<nwDAL.Employee> ReadAllEmployees()
        {
            return dataManager.ReadEntities<nwDAL.Employee>();
        }

        /// <summary>
        /// Read Employee.
        /// </summary>
        /// <param name="entityId">Employee Id that will be read.</param>
        /// <returns>Target Employee.</returns>
        public nwDAL.Employee ReadEmployee(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Employee>(entityId);
        }

        /// <summary>
        /// Update Employee.
        /// </summary>
        /// <param name="employee">updated Employee .</param>
        /// <returns>Updated Employee Id .</returns>
        public string UpdateEmployee(nwDAL.Employee employee)
        {
            return dataManager.UpdateEntity(employee);
        }

        /// <summary>
        /// Delete Employee.
        /// </summary>
        /// <param name="entityId">Target Employee Id.</param>
        /// <returns>Deleted Employee Id.</returns>
        public string DeleteEmployeeById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Employee>(entityId);
        }
		
		/// <summary>
        /// Delete Employee.
        /// </summary>
        /// <param name="entityId">Target Employee.</param>
        /// <returns>Deleted Employee.</returns>
        public string DeleteEmployee(nwDAL.Employee employee)
        {
			string entityId = this.GetEmployeeObjectId(employee);
			return this.DeleteEmployeeById(entityId);
		}
		
		/// <summary>
        /// Searches the Employee.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Employee> SearchEmployee(nwDAL.Employee searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Employee>(searchParameters);
        }
		
        #endregion
		
        #region EmployeeTerritory CRUD Operations

        /// <summary>
        /// Create EmployeeTerritory. 
        /// </summary>
        /// <param name="employeeterritory">Target EmployeeTerritory.</param>
        /// <returns>return EmployeeTerritory Id </returns>
        public string CreateEmployeeTerritory(nwDAL.EmployeeTerritory employeeterritory)
        {
            return dataManager.CreateEntity(employeeterritory);
        }

		/// <summary>
        /// Get EmployeeTerritories ID.
        /// </summary>
        /// <returns>EmployeeTerritories ID</returns>
		public string GetEmployeeTerritoryObjectId(nwDAL.EmployeeTerritory employeeterritory)
        {
			return dataManager.GetEntityId<nwDAL.EmployeeTerritory>(employeeterritory);
		}
		
        /// <summary>
        /// Read EmployeeTerritories .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of EmployeeTerritories.</returns>
        public List<nwDAL.EmployeeTerritory> ReadEmployeeTerritories(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.EmployeeTerritory>(startIndex, count);
        }
		
		/// <summary>
        /// Read EmployeeTerritories .
        /// </summary>
        /// <returns>List of EmployeeTerritories.</returns>
        public List<nwDAL.EmployeeTerritory> ReadAllEmployeeTerritories()
        {
            return dataManager.ReadEntities<nwDAL.EmployeeTerritory>();
        }

        /// <summary>
        /// Read EmployeeTerritory.
        /// </summary>
        /// <param name="entityId">EmployeeTerritory Id that will be read.</param>
        /// <returns>Target EmployeeTerritory.</returns>
        public nwDAL.EmployeeTerritory ReadEmployeeTerritory(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.EmployeeTerritory>(entityId);
        }

        /// <summary>
        /// Update EmployeeTerritory.
        /// </summary>
        /// <param name="employeeterritory">updated EmployeeTerritory .</param>
        /// <returns>Updated EmployeeTerritory Id .</returns>
        public string UpdateEmployeeTerritory(nwDAL.EmployeeTerritory employeeterritory)
        {
            return dataManager.UpdateEntity(employeeterritory);
        }

        /// <summary>
        /// Delete EmployeeTerritory.
        /// </summary>
        /// <param name="entityId">Target EmployeeTerritory Id.</param>
        /// <returns>Deleted EmployeeTerritory Id.</returns>
        public string DeleteEmployeeTerritoryById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.EmployeeTerritory>(entityId);
        }
		
		/// <summary>
        /// Delete EmployeeTerritory.
        /// </summary>
        /// <param name="entityId">Target EmployeeTerritory.</param>
        /// <returns>Deleted EmployeeTerritory.</returns>
        public string DeleteEmployeeTerritory(nwDAL.EmployeeTerritory employeeterritory)
        {
			string entityId = this.GetEmployeeTerritoryObjectId(employeeterritory);
			return this.DeleteEmployeeTerritoryById(entityId);
		}
		
		/// <summary>
        /// Searches the EmployeeTerritory.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.EmployeeTerritory> SearchEmployeeTerritory(nwDAL.EmployeeTerritory searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.EmployeeTerritory>(searchParameters);
        }
		
        #endregion
		
        #region Order CRUD Operations

        /// <summary>
        /// Create Order. 
        /// </summary>
        /// <param name="order">Target Order.</param>
        /// <returns>return Order Id </returns>
        public string CreateOrder(nwDAL.Order order)
        {
            return dataManager.CreateEntity(order);
        }

		/// <summary>
        /// Get Orders ID.
        /// </summary>
        /// <returns>Orders ID</returns>
		public string GetOrderObjectId(nwDAL.Order order)
        {
			return dataManager.GetEntityId<nwDAL.Order>(order);
		}
		
        /// <summary>
        /// Read Orders .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Orders.</returns>
        public List<nwDAL.Order> ReadOrders(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Order>(startIndex, count);
        }
		
		/// <summary>
        /// Read Orders .
        /// </summary>
        /// <returns>List of Orders.</returns>
        public List<nwDAL.Order> ReadAllOrders()
        {
            return dataManager.ReadEntities<nwDAL.Order>();
        }

        /// <summary>
        /// Read Order.
        /// </summary>
        /// <param name="entityId">Order Id that will be read.</param>
        /// <returns>Target Order.</returns>
        public nwDAL.Order ReadOrder(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Order>(entityId);
        }

        /// <summary>
        /// Update Order.
        /// </summary>
        /// <param name="order">updated Order .</param>
        /// <returns>Updated Order Id .</returns>
        public string UpdateOrder(nwDAL.Order order)
        {
            return dataManager.UpdateEntity(order);
        }

        /// <summary>
        /// Delete Order.
        /// </summary>
        /// <param name="entityId">Target Order Id.</param>
        /// <returns>Deleted Order Id.</returns>
        public string DeleteOrderById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Order>(entityId);
        }
		
		/// <summary>
        /// Delete Order.
        /// </summary>
        /// <param name="entityId">Target Order.</param>
        /// <returns>Deleted Order.</returns>
        public string DeleteOrder(nwDAL.Order order)
        {
			string entityId = this.GetOrderObjectId(order);
			return this.DeleteOrderById(entityId);
		}
		
		/// <summary>
        /// Searches the Order.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Order> SearchOrder(nwDAL.Order searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Order>(searchParameters);
        }
		
        #endregion
		
        #region OrderDetail CRUD Operations

        /// <summary>
        /// Create OrderDetail. 
        /// </summary>
        /// <param name="orderdetail">Target OrderDetail.</param>
        /// <returns>return OrderDetail Id </returns>
        public string CreateOrderDetail(nwDAL.OrderDetail orderdetail)
        {
            return dataManager.CreateEntity(orderdetail);
        }

		/// <summary>
        /// Get OrderDetails ID.
        /// </summary>
        /// <returns>OrderDetails ID</returns>
		public string GetOrderDetailObjectId(nwDAL.OrderDetail orderdetail)
        {
			return dataManager.GetEntityId<nwDAL.OrderDetail>(orderdetail);
		}
		
        /// <summary>
        /// Read OrderDetails .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of OrderDetails.</returns>
        public List<nwDAL.OrderDetail> ReadOrderDetails(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.OrderDetail>(startIndex, count);
        }
		
		/// <summary>
        /// Read OrderDetails .
        /// </summary>
        /// <returns>List of OrderDetails.</returns>
        public List<nwDAL.OrderDetail> ReadAllOrderDetails()
        {
            return dataManager.ReadEntities<nwDAL.OrderDetail>();
        }

        /// <summary>
        /// Read OrderDetail.
        /// </summary>
        /// <param name="entityId">OrderDetail Id that will be read.</param>
        /// <returns>Target OrderDetail.</returns>
        public nwDAL.OrderDetail ReadOrderDetail(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.OrderDetail>(entityId);
        }

        /// <summary>
        /// Update OrderDetail.
        /// </summary>
        /// <param name="orderdetail">updated OrderDetail .</param>
        /// <returns>Updated OrderDetail Id .</returns>
        public string UpdateOrderDetail(nwDAL.OrderDetail orderdetail)
        {
            return dataManager.UpdateEntity(orderdetail);
        }

        /// <summary>
        /// Delete OrderDetail.
        /// </summary>
        /// <param name="entityId">Target OrderDetail Id.</param>
        /// <returns>Deleted OrderDetail Id.</returns>
        public string DeleteOrderDetailById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.OrderDetail>(entityId);
        }
		
		/// <summary>
        /// Delete OrderDetail.
        /// </summary>
        /// <param name="entityId">Target OrderDetail.</param>
        /// <returns>Deleted OrderDetail.</returns>
        public string DeleteOrderDetail(nwDAL.OrderDetail orderdetail)
        {
			string entityId = this.GetOrderDetailObjectId(orderdetail);
			return this.DeleteOrderDetailById(entityId);
		}
		
		/// <summary>
        /// Searches the OrderDetail.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.OrderDetail> SearchOrderDetail(nwDAL.OrderDetail searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.OrderDetail>(searchParameters);
        }
		
        #endregion
		
        #region Product CRUD Operations

        /// <summary>
        /// Create Product. 
        /// </summary>
        /// <param name="product">Target Product.</param>
        /// <returns>return Product Id </returns>
        public string CreateProduct(nwDAL.Product product)
        {
            return dataManager.CreateEntity(product);
        }

		/// <summary>
        /// Get Products ID.
        /// </summary>
        /// <returns>Products ID</returns>
		public string GetProductObjectId(nwDAL.Product product)
        {
			return dataManager.GetEntityId<nwDAL.Product>(product);
		}
		
        /// <summary>
        /// Read Products .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Products.</returns>
        public List<nwDAL.Product> ReadProducts(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Product>(startIndex, count);
        }
		
		/// <summary>
        /// Read Products .
        /// </summary>
        /// <returns>List of Products.</returns>
        public List<nwDAL.Product> ReadAllProducts()
        {
            return dataManager.ReadEntities<nwDAL.Product>();
        }

        /// <summary>
        /// Read Product.
        /// </summary>
        /// <param name="entityId">Product Id that will be read.</param>
        /// <returns>Target Product.</returns>
        public nwDAL.Product ReadProduct(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Product>(entityId);
        }

        /// <summary>
        /// Update Product.
        /// </summary>
        /// <param name="product">updated Product .</param>
        /// <returns>Updated Product Id .</returns>
        public string UpdateProduct(nwDAL.Product product)
        {
            return dataManager.UpdateEntity(product);
        }

        /// <summary>
        /// Delete Product.
        /// </summary>
        /// <param name="entityId">Target Product Id.</param>
        /// <returns>Deleted Product Id.</returns>
        public string DeleteProductById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Product>(entityId);
        }
		
		/// <summary>
        /// Delete Product.
        /// </summary>
        /// <param name="entityId">Target Product.</param>
        /// <returns>Deleted Product.</returns>
        public string DeleteProduct(nwDAL.Product product)
        {
			string entityId = this.GetProductObjectId(product);
			return this.DeleteProductById(entityId);
		}
		
		/// <summary>
        /// Searches the Product.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Product> SearchProduct(nwDAL.Product searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Product>(searchParameters);
        }
		
        #endregion
		
        #region Region CRUD Operations

        /// <summary>
        /// Create Region. 
        /// </summary>
        /// <param name="region">Target Region.</param>
        /// <returns>return Region Id </returns>
        public string CreateRegion(nwDAL.Region region)
        {
            return dataManager.CreateEntity(region);
        }

		/// <summary>
        /// Get Regions ID.
        /// </summary>
        /// <returns>Regions ID</returns>
		public string GetRegionObjectId(nwDAL.Region region)
        {
			return dataManager.GetEntityId<nwDAL.Region>(region);
		}
		
        /// <summary>
        /// Read Regions .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Regions.</returns>
        public List<nwDAL.Region> ReadRegions(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Region>(startIndex, count);
        }
		
		/// <summary>
        /// Read Regions .
        /// </summary>
        /// <returns>List of Regions.</returns>
        public List<nwDAL.Region> ReadAllRegions()
        {
            return dataManager.ReadEntities<nwDAL.Region>();
        }

        /// <summary>
        /// Read Region.
        /// </summary>
        /// <param name="entityId">Region Id that will be read.</param>
        /// <returns>Target Region.</returns>
        public nwDAL.Region ReadRegion(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Region>(entityId);
        }

        /// <summary>
        /// Update Region.
        /// </summary>
        /// <param name="region">updated Region .</param>
        /// <returns>Updated Region Id .</returns>
        public string UpdateRegion(nwDAL.Region region)
        {
            return dataManager.UpdateEntity(region);
        }

        /// <summary>
        /// Delete Region.
        /// </summary>
        /// <param name="entityId">Target Region Id.</param>
        /// <returns>Deleted Region Id.</returns>
        public string DeleteRegionById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Region>(entityId);
        }
		
		/// <summary>
        /// Delete Region.
        /// </summary>
        /// <param name="entityId">Target Region.</param>
        /// <returns>Deleted Region.</returns>
        public string DeleteRegion(nwDAL.Region region)
        {
			string entityId = this.GetRegionObjectId(region);
			return this.DeleteRegionById(entityId);
		}
		
		/// <summary>
        /// Searches the Region.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Region> SearchRegion(nwDAL.Region searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Region>(searchParameters);
        }
		
        #endregion
		
        #region Shipper CRUD Operations

        /// <summary>
        /// Create Shipper. 
        /// </summary>
        /// <param name="shipper">Target Shipper.</param>
        /// <returns>return Shipper Id </returns>
        public string CreateShipper(nwDAL.Shipper shipper)
        {
            return dataManager.CreateEntity(shipper);
        }

		/// <summary>
        /// Get Shippers ID.
        /// </summary>
        /// <returns>Shippers ID</returns>
		public string GetShipperObjectId(nwDAL.Shipper shipper)
        {
			return dataManager.GetEntityId<nwDAL.Shipper>(shipper);
		}
		
        /// <summary>
        /// Read Shippers .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Shippers.</returns>
        public List<nwDAL.Shipper> ReadShippers(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Shipper>(startIndex, count);
        }
		
		/// <summary>
        /// Read Shippers .
        /// </summary>
        /// <returns>List of Shippers.</returns>
        public List<nwDAL.Shipper> ReadAllShippers()
        {
            return dataManager.ReadEntities<nwDAL.Shipper>();
        }

        /// <summary>
        /// Read Shipper.
        /// </summary>
        /// <param name="entityId">Shipper Id that will be read.</param>
        /// <returns>Target Shipper.</returns>
        public nwDAL.Shipper ReadShipper(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Shipper>(entityId);
        }

        /// <summary>
        /// Update Shipper.
        /// </summary>
        /// <param name="shipper">updated Shipper .</param>
        /// <returns>Updated Shipper Id .</returns>
        public string UpdateShipper(nwDAL.Shipper shipper)
        {
            return dataManager.UpdateEntity(shipper);
        }

        /// <summary>
        /// Delete Shipper.
        /// </summary>
        /// <param name="entityId">Target Shipper Id.</param>
        /// <returns>Deleted Shipper Id.</returns>
        public string DeleteShipperById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Shipper>(entityId);
        }
		
		/// <summary>
        /// Delete Shipper.
        /// </summary>
        /// <param name="entityId">Target Shipper.</param>
        /// <returns>Deleted Shipper.</returns>
        public string DeleteShipper(nwDAL.Shipper shipper)
        {
			string entityId = this.GetShipperObjectId(shipper);
			return this.DeleteShipperById(entityId);
		}
		
		/// <summary>
        /// Searches the Shipper.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Shipper> SearchShipper(nwDAL.Shipper searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Shipper>(searchParameters);
        }
		
        #endregion
		
        #region Supplier CRUD Operations

        /// <summary>
        /// Create Supplier. 
        /// </summary>
        /// <param name="supplier">Target Supplier.</param>
        /// <returns>return Supplier Id </returns>
        public string CreateSupplier(nwDAL.Supplier supplier)
        {
            return dataManager.CreateEntity(supplier);
        }

		/// <summary>
        /// Get Suppliers ID.
        /// </summary>
        /// <returns>Suppliers ID</returns>
		public string GetSupplierObjectId(nwDAL.Supplier supplier)
        {
			return dataManager.GetEntityId<nwDAL.Supplier>(supplier);
		}
		
        /// <summary>
        /// Read Suppliers .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Suppliers.</returns>
        public List<nwDAL.Supplier> ReadSuppliers(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Supplier>(startIndex, count);
        }
		
		/// <summary>
        /// Read Suppliers .
        /// </summary>
        /// <returns>List of Suppliers.</returns>
        public List<nwDAL.Supplier> ReadAllSuppliers()
        {
            return dataManager.ReadEntities<nwDAL.Supplier>();
        }

        /// <summary>
        /// Read Supplier.
        /// </summary>
        /// <param name="entityId">Supplier Id that will be read.</param>
        /// <returns>Target Supplier.</returns>
        public nwDAL.Supplier ReadSupplier(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Supplier>(entityId);
        }

        /// <summary>
        /// Update Supplier.
        /// </summary>
        /// <param name="supplier">updated Supplier .</param>
        /// <returns>Updated Supplier Id .</returns>
        public string UpdateSupplier(nwDAL.Supplier supplier)
        {
            return dataManager.UpdateEntity(supplier);
        }

        /// <summary>
        /// Delete Supplier.
        /// </summary>
        /// <param name="entityId">Target Supplier Id.</param>
        /// <returns>Deleted Supplier Id.</returns>
        public string DeleteSupplierById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Supplier>(entityId);
        }
		
		/// <summary>
        /// Delete Supplier.
        /// </summary>
        /// <param name="entityId">Target Supplier.</param>
        /// <returns>Deleted Supplier.</returns>
        public string DeleteSupplier(nwDAL.Supplier supplier)
        {
			string entityId = this.GetSupplierObjectId(supplier);
			return this.DeleteSupplierById(entityId);
		}
		
		/// <summary>
        /// Searches the Supplier.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Supplier> SearchSupplier(nwDAL.Supplier searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Supplier>(searchParameters);
        }
		
        #endregion
		
        #region Territory CRUD Operations

        /// <summary>
        /// Create Territory. 
        /// </summary>
        /// <param name="territory">Target Territory.</param>
        /// <returns>return Territory Id </returns>
        public string CreateTerritory(nwDAL.Territory territory)
        {
            return dataManager.CreateEntity(territory);
        }

		/// <summary>
        /// Get Territories ID.
        /// </summary>
        /// <returns>Territories ID</returns>
		public string GetTerritoryObjectId(nwDAL.Territory territory)
        {
			return dataManager.GetEntityId<nwDAL.Territory>(territory);
		}
		
        /// <summary>
        /// Read Territories .
        /// </summary>
        /// <param name="startIndex">Start Index.</param>
        /// <param name="count">Number of object that will be retreived.</param>
        /// <returns>List of Territories.</returns>
        public List<nwDAL.Territory> ReadTerritories(int startIndex, int count)
        {
            return dataManager.ReadEntities<nwDAL.Territory>(startIndex, count);
        }
		
		/// <summary>
        /// Read Territories .
        /// </summary>
        /// <returns>List of Territories.</returns>
        public List<nwDAL.Territory> ReadAllTerritories()
        {
            return dataManager.ReadEntities<nwDAL.Territory>();
        }

        /// <summary>
        /// Read Territory.
        /// </summary>
        /// <param name="entityId">Territory Id that will be read.</param>
        /// <returns>Target Territory.</returns>
        public nwDAL.Territory ReadTerritory(string entityId)
        {
            return dataManager.ReadEntity<nwDAL.Territory>(entityId);
        }

        /// <summary>
        /// Update Territory.
        /// </summary>
        /// <param name="territory">updated Territory .</param>
        /// <returns>Updated Territory Id .</returns>
        public string UpdateTerritory(nwDAL.Territory territory)
        {
            return dataManager.UpdateEntity(territory);
        }

        /// <summary>
        /// Delete Territory.
        /// </summary>
        /// <param name="entityId">Target Territory Id.</param>
        /// <returns>Deleted Territory Id.</returns>
        public string DeleteTerritoryById(string entityId)
        {
            return dataManager.DeleteEntity<nwDAL.Territory>(entityId);
        }
		
		/// <summary>
        /// Delete Territory.
        /// </summary>
        /// <param name="entityId">Target Territory.</param>
        /// <returns>Deleted Territory.</returns>
        public string DeleteTerritory(nwDAL.Territory territory)
        {
			string entityId = this.GetTerritoryObjectId(territory);
			return this.DeleteTerritoryById(entityId);
		}
		
		/// <summary>
        /// Searches the Territory.
        /// </summary>
        /// <param name="searchParameters">The search parameters.</param>
        /// <returns></returns>
		public List<nwDAL.Territory> SearchTerritory(nwDAL.Territory searchParameters)
        {
            return this.dataManager.SearchEntities<nwDAL.Territory>(searchParameters);
        }
		
        #endregion
        #endregion
    }
}